import express from 'express';
import xlsx from 'xlsx';
import cors from 'cors';
import CryptoJS from 'crypto-js';
import jwt from 'jsonwebtoken';
import { fileURLToPath } from 'url';
import path from 'path';
import axios from 'axios';
import mysql from 'mysql2';

const app = express();
const PORT = 3000;
const SECRET_KEY = 'my_secret_key_123';
const JWT_SECRET = 'jwt_secret_key_456';
const PASSWORD_SECRET = 'password_secret_456';

app.use(cors());
app.use(express.json());

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// 创建 MySQL 连接
const db = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '1234',
  database: 'word_memory'
});

// 连接数据库
db.connect((err) => {
  if (err) {
    console.error('数据库连接失败:', err);
    process.exit(1);
  }
  console.log('成功连接到数据库');
});

// 用户登录接口
app.post('/login', (req, res) => {
  const { username, password } = req.body;

  try {
    // 输出前端传递的加密密码
    const decryptedPassword1 = CryptoJS.AES.decrypt(password, PASSWORD_SECRET).toString(CryptoJS.enc.Utf8);

    // 查询数据库验证用户
    const query = 'SELECT * FROM users WHERE username = ?';
    db.execute(query, [username], (err, results) => {
      if (err) {
        console.error('数据库查询失败:', err);
        return res.status(500).json({ success: false, message: '服务器错误' });
      }

      // 检查用户是否存在
      const user = results[0];
      if (!user) {
        return res.status(401).json({ success: false, message: '用户名或密码错误' });
      }

      // 解密数据库中的密码
      const decryptedPassword = CryptoJS.AES.decrypt(user.password, PASSWORD_SECRET).toString(CryptoJS.enc.Utf8);
      console.log(decryptedPassword, decryptedPassword1);
      // 比较前端传递的密码和数据库中的解密密码
      if (decryptedPassword !== decryptedPassword1) {
        return res.status(401).json({ success: false, message: '用户名或密码错误' });
      }

      // 生成 JWT Token
      const token = jwt.sign({ username: user.username }, JWT_SECRET, { expiresIn: '2h' });

      // 返回id字段以及JWT Token
      res.setHeader('Authorization', `Bearer ${token}`);
      res.json({
        success: true,
        message: '登录成功',
        userId: user.id  // 添加返回用户id字段
      });
    });
  } catch (error) {
    console.error('服务器错误:', error);
    res.status(500).json({ success: false, message: '服务器错误' });
  }
});

// 用户注册接口
app.post('/register', (req, res) => {
  const { username, password } = req.body;

  // 检查用户名是否为空
  if (!username || !password) {
    return res.status(400).json({ success: false, message: '用户名和密码不能为空' });
  }

  // 查询用户名是否已存在
  const checkUserQuery = 'SELECT * FROM users WHERE username = ?';
  db.execute(checkUserQuery, [username], (err, results) => {
    if (err) {
      console.error('数据库查询失败:', err);
      return res.status(500).json({ success: false, message: '服务器错误' });
    }

    if (results.length > 0) {
      return res.status(400).json({ success: false, message: '用户名已存在' });
    }

    // 加密密码
    const encryptedPassword = CryptoJS.AES.encrypt(password, PASSWORD_SECRET).toString();

    // 插入用户到数据库
    const insertQuery = 'INSERT INTO users (username, password) VALUES (?, ?)';
    db.execute(insertQuery, [username, encryptedPassword], (err, result) => {
      if (err) {
        console.error('用户注册失败:', err);
        return res.status(500).json({ success: false, message: '服务器错误' });
      }

      res.json({ success: true, message: '注册成功' });
    });
  });
});


// 学习新单词
app.post('/get-unlearned-words', (req, res) => {
  const user_id = parseInt(req.body.user_id, 10);
  const limit = parseInt(req.body.limit, 10);

  // 确保参数有效
  if (isNaN(user_id) || isNaN(limit)) {
    return res.status(400).json({ success: false, message: 'Invalid input parameters' });
  }

  // 拼接 LIMIT 参数
  const query = `
    SELECT w.id AS word_id, w.word, w.definition, w.phonetic
    FROM words w
    LEFT JOIN user_words uw ON w.id = uw.word_id AND uw.user_id = ?
    WHERE uw.word_id IS NULL
    LIMIT ?;
  `;

  // 使用 query 方法执行查询
  db.query(query, [user_id, limit], (err, results) => {
    if (err) {
      console.error('数据库查询失败:', err);
      return res.status(500).json({ success: false, message: '服务器错误' });
    }

    res.json({ success: true, words: results });
  });
});


// 插入学习的单词
app.post('/insert-user-words', (req, res) => {
  const { userId, learnedWords } = req.body;  // 前端传递的用户ID和学习过的单词数组
  console.log(userId, learnedWords);

  // 输入验证
  if (!userId || !learnedWords || learnedWords.length === 0) {
    return res.status(400).json({ success: false, message: '无效的输入数据' });
  }

  // 确保 userId 是有效的整数
  const validUserId = parseInt(userId, 10);
  if (isNaN(validUserId)) {
    return res.status(400).json({ success: false, message: '无效的用户ID' });
  }

  // 当前时间，MySQL 兼容格式
  const currentTime = new Date().toISOString().slice(0, 19).replace('T', ' '); // 转换为 'YYYY-MM-DD HH:MM:SS'
  const nextStudyTime = new Date(new Date().getTime() + 24 * 60 * 60 * 1000).toISOString().slice(0, 19).replace('T', ' ');  // 默认下一次学习时间为 24 小时后

  // 准备批量插入的数据
  const insertData = learnedWords.map(word => {
    return [
      validUserId,  // 用户ID
      word.word_id,  // 单词ID
      currentTime,  // 上次学习时间
      nextStudyTime,  // 下次学习时间
      word.proficiency || 0,  // 学习熟练度，默认为 0
    ];
  });

  console.log(insertData);

  // SQL 插入语句
  const query = `
    INSERT INTO user_words (user_id, word_id, last_study_time, next_study_time, proficiency)
    VALUES ?
  `;

  db.query(query, [insertData], (err, result) => {
    if (err) {
      console.error('批量插入学习记录失败:', err);
      return res.status(500).json({ success: false, message: '服务器错误' });
    }

    res.json({ success: true, message: '学习记录插入成功' });
  });
});



// 查询用户学习统计信息
app.get('/user-stats/:user_id', (req, res) => {
  const user_id = parseInt(req.params.user_id, 10);

  // 确保参数有效
  if (isNaN(user_id)) {
    return res.status(400).json({ success: false, message: 'Invalid user ID' });
  }

  const query = `
    SELECT 
      u.id AS user_id,
      u.username,
      (SELECT COUNT(*) FROM words) AS total_words,
      (SELECT COUNT(*) FROM user_words WHERE user_id = ?) AS learned_words,
      (SELECT COUNT(*) FROM words) - (SELECT COUNT(*) FROM user_words WHERE user_id = ?) AS unlearned_words
    FROM 
      users u
    WHERE 
      u.id = ?;
  `;

  // 使用 query 方法执行查询
  db.query(query, [user_id, user_id, user_id], (err, results) => {
    if (err) {
      console.error('数据库查询失败:', err);
      return res.status(500).json({ success: false, message: '服务器错误' });
    }

    if (results.length === 0) {
      return res.status(404).json({ success: false, message: '用户不存在' });
    }

    res.json({
      success: true,
      stats: {
        user_id: results[0].user_id,
        username: results[0].username,
        total_words: results[0].total_words,
        learned_words: results[0].learned_words,
        unlearned_words: results[0].unlearned_words,
        learning_progress: (results[0].learned_words / results[0].total_words * 100).toFixed(2) + '%'
      }
    });
  });
});


// 插入笔记记录
app.post('/addNote', (req, res) => {
  let { user_id, word_id, note } = req.body;

  // 确保 user_id、word_id 和 note 都已提供
  if (!user_id || !word_id || !note) {
    return res.status(400).send('缺少必要的字段');
  }

  // 将 user_id 和 word_id 转换为整数
  user_id = parseInt(user_id, 10);
  word_id = parseInt(word_id, 10);
  console.log(`收到请求：user_id=${user_id}, word_id=${word_id}, note=${note}`);
  // 检查转换是否成功
  if (isNaN(user_id) || isNaN(word_id)) {
    return res.status(400).send('user_id 或 word_id 必须是有效的整数');
  }
  const query = 'INSERT INTO notes (user_id, word_id, note) VALUES (?, ?, ?)';

  db.query(query, [user_id, word_id, note], (err, result) => {
    if (err) {
      console.error('插入笔记失败:', err);
      return res.status(500).send('服务器错误');
    }
    res.status(200).send('笔记添加成功');
  });
});

// 查询用户单词笔记记录
app.get('/getNotes', (req, res) => {
  let { user_id, word_id } = req.query;

  // 确保 user_id 和 word_id 都已提供
  if (!user_id || !word_id) {
    return res.status(400).send('缺少必要的字段');
  }

  // 将 user_id 和 word_id 转换为整数
  user_id = parseInt(user_id, 10);
  word_id = parseInt(word_id, 10);
  console.log(`收到请求：user_id=${user_id}, word_id=${word_id}`);

  // 检查转换是否成功
  if (isNaN(user_id) || isNaN(word_id)) {
    return res.status(400).send('user_id 或 word_id 必须是有效的整数');
  }

  const query = `
    SELECT n.id, n.user_id, n.word_id, n.note, n.created_at, n.updated_at
    FROM notes n
    WHERE n.user_id = ? AND n.word_id = ?;
  `;

  db.query(query, [user_id, word_id], (err, result) => {
    if (err) {
      console.error('查询笔记失败:', err);
      return res.status(500).send('服务器错误');
    }

    if (result.length === 0) {
      return res.status(404).send('没有找到该单词的笔记');
    }

    res.status(200).json(result);
  });
});










// 读取 Excel 文件并返回加密数据
app.get('/data', (req, res) => {
  try {
    const filePath = path.join(__dirname, './Data/Data.xls');
    const workbook = xlsx.readFile(filePath);
    const sheetName = workbook.SheetNames[0];
    const worksheet = workbook.Sheets[sheetName];
    const jsonData = xlsx.utils.sheet_to_json(worksheet, { header: 1 });
    const encryptedData = CryptoJS.AES.encrypt(JSON.stringify(jsonData), SECRET_KEY).toString();
    res.json({ success: true, data: encryptedData });
  } catch (error) {
    console.error('读取 Excel 失败:', error);
    res.status(500).json({ success: false, message: '服务器错误' });
  }
});

// AI 聊天接口，调用外部 API
app.post('/ai-chat', async (req, res) => {
  try {
    const data = req.body;
    console.log('Request Body:', data);
    // 组装请求体
    const requestBody = {
      model: "4.0Ultra",
      messages: data.messages,
      stream: false,
      max_tokens: 1024
    };
    // 发送请求到 AI API
    const response = await axios.post(
      'https://spark-api-open.xf-yun.com/v1/chat/completions',
      requestBody,
      {
        headers: {
          'Authorization': 'Bearer joRSxASbPrOtUadecqgA:OVtblvXIkRXQZGDhUEyw',
          'Content-Type': 'application/json',
        }
      }
    );
    res.json(response.data);
  } catch (error) {
    console.error('Error:', error.response?.data || error);
    res.status(500).json({ error: 'Internal Server Error' });
  }
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`🚀 服务器运行在 http://localhost:${PORT}`);
});